From df03a1704a25270d7b108dfb843c9ce67da1d57b Mon Sep 17 00:00:00 2001 From: tsteven4 <13596209+tsteven4@users.noreply.github.com> Date: Sat, 18 Jan 2020 09:04:07 -0700 Subject: [PATCH] retire cet_convert_strings (#459) * prepare to eliminate char strings from garmin_fs_t. * retire cet_covnert_strings The only use was for garmin specific data(gmsd). gmsd is migrated from char strings to QStrings, and any necessary conversions are handled within the formats using gmsd. This takes main out of the string conversion business. * fix gmsd related memory leaks. and eliminate a little back and forth between char strings and QStrings. csv_stringtrim has 3 signatures: 1. char*,char*,int returning char* that must be free'd. 2. QString,QString returning QString 3. QString,QString,int returing QString We may want to consider replacing 2. with 3. and a default for the 3rd argument. --- an1.cc | 3 - cet_util.cc | 135 ------------------------- cet_util.h | 5 - defs.h | 4 - destinator.cc | 20 ++-- g7towin.cc | 22 ++--- garmin_fs.cc | 262 ++++++++++++++++++------------------------------- garmin_fs.h | 180 ++++++++++++++++++++++++--------- garmin_gpi.cc | 122 +++++++++++------------ garmin_txt.cc | 40 ++++---- gdb.cc | 81 +++++++-------- gpx.cc | 2 +- lowranceusr.cc | 1 - main.cc | 7 +- ozi.cc | 1 - random.cc | 61 +++++------- unicsv.cc | 66 ++++++------- waypt.cc | 2 +- xcsv.cc | 71 +++++++------- xmltag.cc | 1 - 20 files changed, 463 insertions(+), 623 deletions(-) diff --git a/an1.cc b/an1.cc index ede6bfcab..80c34bc5e 100644 --- a/an1.cc +++ b/an1.cc @@ -284,7 +284,6 @@ static an1_waypoint_record* Alloc_AN1_Waypoint() result->fs.type = FS_AN1W; result->fs.copy = Copy_AN1_Waypoint; result->fs.destroy = Destroy_AN1_Waypoint; - result->fs.convert = nullptr; return result; } @@ -309,7 +308,6 @@ static an1_vertex_record* Alloc_AN1_Vertex() result->fs.type = FS_AN1V; result->fs.copy = Copy_AN1_Vertex; result->fs.destroy = Destroy_AN1_Vertex; - result->fs.convert = nullptr; return result; } @@ -338,7 +336,6 @@ static an1_line_record* Alloc_AN1_Line() result->fs.type = FS_AN1L; result->fs.copy = Copy_AN1_Line; result->fs.destroy = Destroy_AN1_Line; - result->fs.convert = nullptr; return result; } diff --git a/cet_util.cc b/cet_util.cc index 6385d2e5b..d160ec2c0 100644 --- a/cet_util.cc +++ b/cet_util.cc @@ -44,7 +44,6 @@ struct cet_cs_alias_t { static cet_cs_alias_t* cet_cs_alias; static int cet_cs_alias_ct = 0; static int cet_cs_vec_ct = 0; -static int cet_output = 0; /* %%% fixed inbuild character sets %%% */ @@ -308,137 +307,3 @@ cet_convert_init(const QString& cs_name, const int force) } } } - -/* -------------------------------------------------------------------- */ - -static void -cet_flag_waypt(const Waypoint* wpt) -{ - (const_cast(wpt))->wpt_flags.cet_converted = 1; -} - -static void -cet_flag_all() -{ - waypt_disp_all(cet_flag_waypt); - route_disp_all(nullptr, nullptr, cet_flag_waypt); - track_disp_all(nullptr, nullptr, cet_flag_waypt); -} - -/* -------------------------------------------------------------------- */ -/* %%% complete data strings transformation %%% */ -/* -------------------------------------------------------------------- */ - -static char* (*converter)(const char*) = nullptr; - -/* two converters */ - -static char* -cet_convert_to_utf8(const char* str) -{ - return cet_str_any_to_utf8(str, global_opts.charset); -} - -static char* -cet_convert_from_utf8(const char* str) -{ - return cet_str_utf8_to_any(str, global_opts.charset); -} - -/* cet_convert_string: internal used within cet_convert_strings process */ - -char* -cet_convert_string(char* str) -{ - if (str == nullptr) { - return nullptr; /* return origin if empty or NULL */ - } else if (*str == '\0') { - return str; - } - - char* res = converter(str); - xfree(str); - return res; -} - -const char* -cet_convert_string(const QString& str) -{ - // FIXME: this is really weird. Since cet_convert_string wants to free - // its argument (!) we make a duplicate just to satisfy that kind of goofy - // requirement. - return cet_convert_string(xstrdup(str)); -} - -/* cet_convert_waypt: internal used within cet_convert_strings process */ - -static void -cet_convert_waypt(const Waypoint* wpt) -{ - auto* w = const_cast(wpt); - - if ((cet_output == 0) && (w->wpt_flags.cet_converted != 0)) { - return; - } - - w->wpt_flags.cet_converted = 1; - - format_specific_data* fs = wpt->fs; - while (fs != nullptr) { - if (fs->convert != nullptr) { - fs->convert(fs); - } - fs = fs->next; - } -} - -/* %%% cet_convert_strings (public) %%% - * - * - Convert all well known strings of GPS data from or to UTF-8 - - * - * !!! One of "source" or "target" must be internal cet_cs_vec_utf8 or NULL !!! */ - -void -cet_convert_strings(const cet_cs_vec_t* source, const cet_cs_vec_t* target) -{ - const char* cs_name_from, *cs_name_to; - - converter = nullptr; - - if ((source == nullptr) || (source == &cet_cs_vec_utf8)) { - if ((target == nullptr) || (target == &cet_cs_vec_utf8)) { - cet_flag_all(); - return; - } - - cet_output = 1; - - converter = cet_convert_from_utf8; - cs_name_from = cet_cs_vec_utf8.name; - cs_name_to = target->name; - } else { - if ((target != nullptr) && (target != &cet_cs_vec_utf8)) { - fatal(MYNAME ": Internal error!\n"); - } - - cet_output = 0; - - converter = cet_convert_to_utf8; - cs_name_to = cet_cs_vec_utf8.name; - cs_name_from = source->name; - } - - if (global_opts.debug_level > 0) { - printf(MYNAME ": Converting from \"%s\" to \"%s\"", cs_name_from, cs_name_to); - } - - waypt_disp_all(cet_convert_waypt); - route_disp_all(nullptr, nullptr, cet_convert_waypt); - track_disp_all(nullptr, nullptr, cet_convert_waypt); - - cet_output = 0; - - if (global_opts.debug_level > 0) { - printf(", done.\n"); - } -} diff --git a/cet_util.h b/cet_util.h index 4214413bc..83fe1f008 100644 --- a/cet_util.h +++ b/cet_util.h @@ -47,14 +47,9 @@ extern cet_cs_vec_t cet_cs_vec_utf8; [[deprecated]] char* cet_str_any_to_any(const char* src, const cet_cs_vec_t* src_vec, const cet_cs_vec_t* dest_vec); -/* cet_convert_string: !!! ONLY VALID WITHIN 'cet_convert_strings' process !!! */ -char* cet_convert_string(char* str); -const char* cet_convert_string(const QString& str); - /* gpsbabel extensions */ void cet_convert_init(const QString& cs_name, int force); -void cet_convert_strings(const cet_cs_vec_t* source, const cet_cs_vec_t* target); void cet_convert_deinit(); #endif // CET_UTIL_H_INCLUDED_ diff --git a/defs.h b/defs.h index 41a7ff878..c906bc458 100644 --- a/defs.h +++ b/defs.h @@ -295,7 +295,6 @@ public: using fs_destroy = void (*)(void*); using fs_copy = void (*)(void**, void*); -using fs_convert = void (*)(void*); struct format_specific_data { long type{0}; @@ -303,7 +302,6 @@ struct format_specific_data { fs_destroy destroy{nullptr}; fs_copy copy{nullptr}; - fs_convert convert{nullptr}; }; class gb_color @@ -382,7 +380,6 @@ class wp_flags public: wp_flags() : shortname_is_synthetic(0), - cet_converted(0), fmt_use(0), temperature(0), proximity(0), @@ -393,7 +390,6 @@ public: is_split(0), new_trkseg(0) {} unsigned int shortname_is_synthetic:1; - unsigned int cet_converted:1; /* strings are converted to UTF8; interesting only for input */ unsigned int fmt_use:2; /* lightweight "extra data" */ /* "flagged fields" */ unsigned int temperature:1; /* temperature field is set */ diff --git a/destinator.cc b/destinator.cc index 4ec15f112..4a31cdb05 100644 --- a/destinator.cc +++ b/destinator.cc @@ -48,7 +48,7 @@ static gpsdata_type data_type; static garmin_fs_t* gmsd_init(Waypoint* wpt) { - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); if (gmsd == nullptr) { gmsd = garmin_fs_alloc(-1); fs_chain_add(&wpt->fs, (format_specific_data*) gmsd); @@ -181,19 +181,19 @@ destinator_read_poi() str += " "; str += hnum; } - GMSD_SETSTRQ(addr, str); + garmin_fs_t::set_addr(gmsd, str); } - if ((str = read_wcstr(0), !str.isEmpty())) { /* city */ + if (!(str = read_wcstr(0)).isEmpty()) { /* city */ gmsd = gmsd_init(wpt); - GMSD_SETSTRQ(city, str); + garmin_fs_t::set_city(gmsd, str); } (void) read_wcstr(1); /* unknown */ - if ((str = read_wcstr(0), !str.isEmpty())) { /* postcode */ + if (!(str = read_wcstr(0)).isEmpty()) { /* postcode */ gmsd = gmsd_init(wpt); - GMSD_SETSTRQ(postal_code, str); + garmin_fs_t::set_postal_code(gmsd, str); } (void) read_wcstr(1); /* unknown */ @@ -373,17 +373,17 @@ destinator_read() static void destinator_wpt_disp(const Waypoint* wpt) { - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); write_wcstr(DST_DYN_POI); write_wcstr((!wpt->shortname.isEmpty()) ? wpt->shortname : "WPT"); write_wcstr((!wpt->notes.isEmpty()) ? wpt->notes : wpt->description); write_wcstr(nullptr); /* house number */ - write_wcstr(GMSD_GET(addr, NULL)); /* street */ - write_wcstr(GMSD_GET(city, NULL)); /* city */ + write_wcstr(garmin_fs_t::get_addr(gmsd, nullptr)); /* street */ + write_wcstr(garmin_fs_t::get_city(gmsd, nullptr)); /* city */ write_wcstr(nullptr); /* unknown */ - write_wcstr(GMSD_GET(postal_code, NULL)); /* postcode */ + write_wcstr(garmin_fs_t::get_postal_code(gmsd, nullptr)); /* postcode */ write_wcstr(nullptr); /* unknown */ gbfputint32(0, fout); diff --git a/g7towin.cc b/g7towin.cc index 948a9518a..9e94ef4fc 100644 --- a/g7towin.cc +++ b/g7towin.cc @@ -75,7 +75,7 @@ static void parse_line(char* buff, int index, const char* delimiter, Waypoint* wpt) { char* cin; - garmin_fs_p gmsd = GMSD_FIND(wpt); + garmin_fs_p gmsd = garmin_fs_t::find(wpt); while ((cin = csv_lineparse(buff, delimiter, "", index++))) { @@ -121,11 +121,11 @@ parse_line(char* buff, int index, const char* delimiter, Waypoint* wpt) case WAYPT__OFS + 4: if (strcmp(cin, "S+C") == 0) { - GMSD_SET(display, gt_display_mode_symbol_and_comment); + garmin_fs_t::set_display(gmsd, gt_display_mode_symbol_and_comment); } else if (strcmp(cin, "S") == 0) { - GMSD_SET(display, gt_display_mode_symbol); + garmin_fs_t::set_display(gmsd, gt_display_mode_symbol); } else if (strcmp(cin, "S+N") == 0) { - GMSD_SET(display, gt_display_mode_symbol_and_name); + garmin_fs_t::set_display(gmsd, gt_display_mode_symbol_and_name); } break; @@ -136,32 +136,32 @@ parse_line(char* buff, int index, const char* delimiter, Waypoint* wpt) case WPT_cA_OFS + 4: case WPT_c4_OFS + 2: - GMSD_SETSTR(city, cin); + garmin_fs_t::set_city(gmsd, cin); break; case WPT_cA_OFS + 5: case WPT_c4_OFS + 3: - GMSD_SETSTR(state, cin); + garmin_fs_t::set_state(gmsd, cin); break; case WPT_cA_OFS + 6: case WPT_c4_OFS + 4: - GMSD_SETSTR(cc, cin); + garmin_fs_t::set_cc(gmsd, cin); break; case WPT_cB_OFS + 1: case WPT_c6_OFS + 2: - GMSD_SETSTR(facility, cin); + garmin_fs_t::set_facility(gmsd, cin); break; case WPT_cB_OFS + 2: case WPT_c6_OFS + 3: - GMSD_SETSTR(addr, cin); + garmin_fs_t::set_addr(gmsd, cin); break; case WPT_cB_OFS + 3: /*cross road */ case WPT_c6_OFS + 4: - GMSD_SETSTR(cross_road, cin); + garmin_fs_t::set_cross_road(gmsd, cin); break; case TRKPT__OFS + 2: /* altitude */ @@ -203,7 +203,7 @@ parse_line(char* buff, int index, const char* delimiter, Waypoint* wpt) case WPT_cD_OFS + 3: categories = atoi(cin); if (categories != 0) { - GMSD_SET(category, atoi(cin)); + garmin_fs_t::set_category(gmsd, atoi(cin)); } break; diff --git a/garmin_fs.cc b/garmin_fs.cc index 93e066727..291845b82 100644 --- a/garmin_fs.cc +++ b/garmin_fs.cc @@ -37,11 +37,10 @@ garmin_fs_t* garmin_fs_alloc(const int protocol) { - garmin_fs_t* result = (garmin_fs_t*)xcalloc(1, sizeof(*result)); + garmin_fs_t* result = new garmin_fs_t; result->fs.type = FS_GMSD; result->fs.copy = (fs_copy) garmin_fs_copy; result->fs.destroy = garmin_fs_destroy; - result->fs.convert = garmin_fs_convert; result->fs.next = nullptr; result->protocol = protocol; @@ -52,58 +51,21 @@ garmin_fs_alloc(const int protocol) void garmin_fs_destroy(void* fs) { - garmin_fs_t* data = (garmin_fs_t*) fs; - if (data != nullptr) { - garmin_ilink_t* ilinks; - - if (data->addr != nullptr) { - xfree(data->addr); - } - if (data->cc != nullptr) { - xfree(data->cc); - } - if (data->city != nullptr) { - xfree(data->city); - } - if (data->country != nullptr) { - xfree(data->country); - } - if (data->cross_road != nullptr) { - xfree(data->cross_road); - } - if (data->facility != nullptr) { - xfree(data->facility); - } - if (data->phone_nr != nullptr) { - xfree(data->phone_nr); - } - if (data->phone_nr2 != nullptr) { - xfree(data->phone_nr2); - } - if (data->fax_nr != nullptr) { - xfree(data->fax_nr); - } - if (data->email != nullptr) { - xfree(data->email); - } - if (data->postal_code != nullptr) { - xfree(data->postal_code); - } - if (data->state != nullptr) { - xfree(data->state); - } + delete (garmin_fs_t*) fs; +} - if ((ilinks = data->ilinks) != nullptr) { - ilinks->ref_count--; - if (ilinks->ref_count <= 0) { - while (ilinks != nullptr) { - garmin_ilink_t* tmp = ilinks; - ilinks = ilinks->next; - xfree(tmp); - } +garmin_fs_t::~garmin_fs_t() +{ + garmin_ilink_t* links; + if ((links = ilinks) != nullptr) { + links->ref_count--; + if (links->ref_count <= 0) { + while (links != nullptr) { + garmin_ilink_t* tmp = links; + links = links->next; + xfree(tmp); } } - xfree(data); } } @@ -113,69 +75,39 @@ void garmin_fs_copy(garmin_fs_t** dest, garmin_fs_t* src) *dest = nullptr; return; } - *dest = (garmin_fs_t*) xmalloc(sizeof(*src)); - - /* do not copy interlinks, only increment the reference counter */ - if (src->ilinks != nullptr) { - src->ilinks->ref_count++; - } - - memcpy(*dest, src, sizeof(*src)); - - (*dest)->addr = (src->addr != nullptr) ? xstrdup(src->addr) : nullptr; - (*dest)->cc = (src->cc != nullptr) ? xstrdup(src->cc) : nullptr; - (*dest)->city = (src->city != nullptr) ? xstrdup(src->city) : nullptr; - (*dest)->country = (src->country != nullptr) ? xstrdup(src->country) : nullptr; - (*dest)->cross_road = (src->cross_road != nullptr) ? xstrdup(src->cross_road) : nullptr; - (*dest)->facility = (src->facility != nullptr) ? xstrdup(src->facility) : nullptr; - (*dest)->phone_nr = (src->phone_nr != nullptr) ? xstrdup(src->phone_nr) : nullptr; - (*dest)->phone_nr2 = (src->phone_nr2 != nullptr) ? xstrdup(src->phone_nr2) : nullptr; - (*dest)->fax_nr = (src->fax_nr != nullptr) ? xstrdup(src->fax_nr) : nullptr; - (*dest)->email = (src->email != nullptr) ? xstrdup(src->email) : nullptr; - (*dest)->postal_code = (src->postal_code != nullptr) ? xstrdup(src->postal_code) : nullptr; - (*dest)->state = (src->state != nullptr) ? xstrdup(src->state) : nullptr; + *dest = new garmin_fs_t(*src); } -void garmin_fs_convert(void* fs) +garmin_fs_t::garmin_fs_t(const garmin_fs_t& other) : + fs(other.fs), + flags(other.flags), + protocol(other.protocol), + icon(other.icon), + wpt_class(other.wpt_class), + display(other.display), + category(other.category), + city(other.city), + facility(other.facility), + state(other.state), + cc(other.cc), + cross_road(other.cross_road), + addr(other.addr), + country(other.country), + phone_nr(other.phone_nr), + phone_nr2(other.phone_nr2), + fax_nr(other.fax_nr), + postal_code(other.postal_code), + email(other.email), + ilinks(other.ilinks) { - garmin_fs_t* gmsd = (garmin_fs_t*) fs; - - if (gmsd->addr) { - gmsd->addr = cet_convert_string(gmsd->addr); - } - if (gmsd->cc) { - gmsd->cc = cet_convert_string(gmsd->cc); - } - if (gmsd->city) { - gmsd->city = cet_convert_string(gmsd->city); - } - if (gmsd->country) { - gmsd->country = cet_convert_string(gmsd->country); - } - if (gmsd->cross_road) { - gmsd->cross_road = cet_convert_string(gmsd->cross_road); - } - if (gmsd->facility) { - gmsd->facility = cet_convert_string(gmsd->facility); - } - if (gmsd->phone_nr) { - gmsd->phone_nr = cet_convert_string(gmsd->phone_nr); - } - if (gmsd->phone_nr2) { - gmsd->phone_nr2 = cet_convert_string(gmsd->phone_nr2); - } - if (gmsd->fax_nr) { - gmsd->fax_nr = cet_convert_string(gmsd->fax_nr); - } - if (gmsd->email) { - gmsd->email = cet_convert_string(gmsd->email); - } - if (gmsd->postal_code) { - gmsd->postal_code = cet_convert_string(gmsd->postal_code); - } - if (gmsd->state) { - gmsd->state = cet_convert_string(gmsd->state); + /* do not deep copy interlinks, only increment the reference counter */ + if (ilinks != nullptr) { + ilinks->ref_count++; } + +#ifdef GMSD_EXPERIMENTAL + memcopy(subclass, other.subclass, sizeof(subclass)); +#endif } /* GPX - out */ @@ -184,30 +116,30 @@ void garmin_fs_xml_fprint(const Waypoint* waypt, QXmlStreamWriter* writer) { - garmin_fs_t* gmsd = GMSD_FIND(waypt); + garmin_fs_t* gmsd = garmin_fs_t::find(waypt); if (gmsd == nullptr) { return; } /* Find out if there is at least one field set */ - const char* addr = GMSD_GET(addr, ""); - if (! *addr) { - addr = GMSD_GET(city, ""); + QString addr = garmin_fs_t::get_addr(gmsd, ""); + if (addr.isEmpty()) { + addr = garmin_fs_t::get_city(gmsd, ""); } - if (! *addr) { - addr = GMSD_GET(country, ""); + if (addr.isEmpty()) { + addr = garmin_fs_t::get_country(gmsd, ""); } - if (! *addr) { - addr = GMSD_GET(postal_code, ""); + if (addr.isEmpty()) { + addr = garmin_fs_t::get_postal_code(gmsd, ""); } - if (! *addr) { - addr = GMSD_GET(state, ""); + if (addr.isEmpty()) { + addr = garmin_fs_t::get_state(gmsd, ""); } - const char* phone = GMSD_GET(phone_nr, ""); + QString phone = garmin_fs_t::get_phone_nr(gmsd, ""); - if (*addr || *phone || + if (!addr.isEmpty() || !phone.isEmpty() || (gmsd->flags.category && gmsd->category) || WAYPT_HAS(waypt, depth) || WAYPT_HAS(waypt, proximity) || @@ -252,29 +184,29 @@ garmin_fs_xml_fprint(const Waypoint* waypt, } writer->writeEndElement(); // gpxx:Categories } - if (*addr) { - char* str; + if (!addr.isEmpty()) { + QString str; writer->writeStartElement(QStringLiteral("gpxx:Address")); - if ((str = GMSD_GET(addr, NULL))) { + if (!(str = garmin_fs_t::get_addr(gmsd, nullptr)).isEmpty()) { writer->writeTextElement(QStringLiteral("gpxx:StreetAddress"), str); } - if ((str = GMSD_GET(city, NULL))) { + if (!(str = garmin_fs_t::get_city(gmsd, nullptr)).isEmpty()) { writer->writeTextElement(QStringLiteral("gpxx:City"), str); } - if ((str = GMSD_GET(state, NULL))) { + if (!(str = garmin_fs_t::get_state(gmsd, nullptr)).isEmpty()) { writer->writeTextElement(QStringLiteral("gpxx:State"), str); } - if ((str = GMSD_GET(country, NULL))) { + if (!(str = garmin_fs_t::get_country(gmsd, nullptr)).isEmpty()) { writer->writeTextElement(QStringLiteral("gpxx:Country"), str); } - if ((str = GMSD_GET(postal_code, NULL))) { + if (!(str = garmin_fs_t::get_postal_code(gmsd, nullptr)).isEmpty()) { writer->writeTextElement(QStringLiteral("gpxx:PostalCode"), str); } writer->writeEndElement(); // /gpxx::Address } - if (*phone) { + if (!phone.isEmpty()) { writer->writeTextElement(QStringLiteral("gpxx:PhoneNumber"), phone); } @@ -285,11 +217,11 @@ garmin_fs_xml_fprint(const Waypoint* waypt, } void -garmin_fs_xml_convert(const int base_tag, int tag, const QString& Qcdatastr, Waypoint* waypt) +garmin_fs_xml_convert(const int base_tag, int tag, const QString& qstr, Waypoint* waypt) { // FIXME: eliminate C string copy/use here: - const char *cdatastr = xstrdup(Qcdatastr); - garmin_fs_t* gmsd = GMSD_FIND(waypt); + const char *cdatastr = xstrdup(qstr); + garmin_fs_t* gmsd = garmin_fs_t::find(waypt); if (gmsd == nullptr) { gmsd = garmin_fs_alloc(-1); fs_chain_add(&waypt->fs, (format_specific_data*) gmsd); @@ -329,11 +261,11 @@ garmin_fs_xml_convert(const int base_tag, int tag, const QString& Qcdatastr, Way break; case 4: if (case_ignore_strcmp(cdatastr, "SymbolOnly") == 0) { - GMSD_SET(display, gt_display_mode_symbol); + garmin_fs_t::set_display(gmsd, gt_display_mode_symbol); } else if (case_ignore_strcmp(cdatastr, "SymbolAndDescription") == 0) { - GMSD_SET(display, gt_display_mode_symbol_and_comment); + garmin_fs_t::set_display(gmsd, gt_display_mode_symbol_and_comment); } else { - GMSD_SET(display, gt_display_mode_symbol_and_name); + garmin_fs_t::set_display(gmsd, gt_display_mode_symbol_and_name); } break; case 6: @@ -347,22 +279,22 @@ garmin_fs_xml_convert(const int base_tag, int tag, const QString& Qcdatastr, Way } break; case 7: - GMSD_SETSTR(addr, cdatastr); + garmin_fs_t::set_addr(gmsd, cdatastr); break; case 8: - GMSD_SETSTR(city, cdatastr); + garmin_fs_t::set_city(gmsd, cdatastr); break; case 9: - GMSD_SETSTR(state, cdatastr); + garmin_fs_t::set_state(gmsd, cdatastr); break; case 10: - GMSD_SETSTR(country, cdatastr); + garmin_fs_t::set_country(gmsd, cdatastr); break; case 11: - GMSD_SETSTR(postal_code, cdatastr); + garmin_fs_t::set_postal_code(gmsd, cdatastr); break; case 12: - GMSD_SETSTR(phone_nr, cdatastr); + garmin_fs_t::set_phone_nr(gmsd, cdatastr); break; } xfree(cdatastr); @@ -413,14 +345,14 @@ garmin_fs_merge_category(const char* category_name, Waypoint* waypt) return 0; } - garmin_fs_t* gmsd = GMSD_FIND(waypt); - cat = cat | (GMSD_GET(category, 0)); + garmin_fs_t* gmsd = garmin_fs_t::find(waypt); + cat = cat | (garmin_fs_t::get_category(gmsd, 0)); if (gmsd == nullptr) { gmsd = garmin_fs_alloc(-1); fs_chain_add(&waypt->fs, (format_specific_data*) gmsd); } - GMSD_SET(category, cat); + garmin_fs_t::set_category(gmsd, cat); return 1; } @@ -433,12 +365,12 @@ garmin_fs_garmin_after_read(const GPS_PWay way, Waypoint* wpt, const int protoid /* nothing happens until gmsd is allocated some lines above */ /* !!! class needs protocol specific conversion !!! (ToDo) - GMSD_SET(wpt_class, way[i]->wpt_class); + garmin_fs_t::set_wpt_class(gmsd, way[i]->wpt_class); */ /* flagged data fields */ - GMSD_SET(display, gt_switch_display_mode_value(way->dspl, gps_waypt_type, 1)); + garmin_fs_t::set_display(gmsd, gt_switch_display_mode_value(way->dspl, gps_waypt_type, 1)); if (way->category != 0) { - GMSD_SET(category, way->category); + garmin_fs_t::set_category(gmsd, way->category); } if (way->dst < 1.0e25f) { WAYPT_SET(wpt, proximity, way->dst); @@ -449,18 +381,19 @@ garmin_fs_garmin_after_read(const GPS_PWay way, Waypoint* wpt, const int protoid if (way->dpth < 1.0e25f) { WAYPT_SET(wpt, depth, way->dpth); } - GMSD_SETNSTR(cc, way->cc, sizeof(way->cc)); - GMSD_SETNSTR(state, way->state, sizeof(way->state)); - GMSD_SETSTR(city, way->city); - GMSD_SETSTR(facility, way->facility); - GMSD_SETSTR(cross_road, way->cross_road); - GMSD_SETSTR(addr, way->addr); + // These use STRTOUNICODE which uses gobal_opts.codec. + garmin_fs_t::set_cc(gmsd, STRTOUNICODE(QByteArray(way->cc, sizeof(way->cc)).constData())); + garmin_fs_t::set_city(gmsd, STRTOUNICODE(QByteArray(way->city, sizeof(way->city)).constData())); + garmin_fs_t::set_state(gmsd, STRTOUNICODE(QByteArray(way->state, sizeof(way->state)).constData())); + garmin_fs_t::set_facility(gmsd, STRTOUNICODE(QByteArray(way->facility, sizeof(way->facility)).constData())); + garmin_fs_t::set_cross_road(gmsd, STRTOUNICODE(QByteArray(way->cross_road, sizeof(way->cross_road)).constData())); + garmin_fs_t::set_addr(gmsd, STRTOUNICODE(QByteArray(way->addr, sizeof(way->addr)).constData())); } void garmin_fs_garmin_before_write(const Waypoint* wpt, GPS_PWay way, const int protoid) { - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); (void)protoid; // unused for now. @@ -469,19 +402,20 @@ garmin_fs_garmin_before_write(const Waypoint* wpt, GPS_PWay way, const int proto } /* ToDo: protocol specific conversion of class - way[i]->wpt_class = GMSD_GET(wpt_class, way[i]->wpt_class); + way[i]->wpt_class = garmin_fs_t::get_wpt_class(gmsd, way[i]->wpt_class); */ way->dspl = gt_switch_display_mode_value( - GMSD_GET(display, way->dspl), gps_waypt_type, 0); - way->category = GMSD_GET(category, way->category); + garmin_fs_t::get_display(gmsd, way->dspl), gps_waypt_type, 0); + way->category = garmin_fs_t::get_category(gmsd, way->category); way->dpth = WAYPT_GET(wpt, depth, way->dpth); way->dst = WAYPT_GET(wpt, proximity, way->dpth); way->temperature = WAYPT_GET(wpt, temperature, way->temperature); - GMSD_GETNSTR(cc, way->cc, sizeof(way->cc)); - GMSD_GETNSTR(city, way->city, sizeof(way->city)); - GMSD_GETNSTR(state, way->state, sizeof(way->state)); - GMSD_GETNSTR(facility, way->facility, sizeof(way->facility)); - GMSD_GETNSTR(cross_road, way->cross_road, sizeof(way->cross_road)); - GMSD_GETNSTR(addr, way->addr, sizeof(way->addr)); + // These use STRFROMUNICODE which uses gobal_opts.codec. + strncpy(way->cc, STRFROMUNICODE(garmin_fs_t::get_cc(gmsd, nullptr)), sizeof(way->cc)); + strncpy(way->city, STRFROMUNICODE(garmin_fs_t::get_city(gmsd, nullptr)), sizeof(way->city)); + strncpy(way->state, STRFROMUNICODE(garmin_fs_t::get_state(gmsd, nullptr)), sizeof(way->state)); + strncpy(way->facility, STRFROMUNICODE(garmin_fs_t::get_facility(gmsd, nullptr)), sizeof(way->facility)); + strncpy(way->cross_road, STRFROMUNICODE(garmin_fs_t::get_cross_road(gmsd, nullptr)), sizeof(way->cross_road)); + strncpy(way->addr, STRFROMUNICODE(garmin_fs_t::get_addr(gmsd, nullptr)), sizeof(way->addr)); } diff --git a/garmin_fs.h b/garmin_fs.h index 6cedcdd0c..0ee77300c 100644 --- a/garmin_fs.h +++ b/garmin_fs.h @@ -35,31 +35,6 @@ }; */ -/* macros */ - -#define GMSD_FIND(a) (garmin_fs_t *) fs_chain_find((a)->fs, FS_GMSD) -#define GMSD_HAS(a) (gmsd && gmsd->flags.a) - -/* GMSD_GET(a,b): a = any gmsd field, b = default value */ -#define GMSD_GET(a,b) ((gmsd) && (gmsd->flags.a)) ? (gmsd->a) : (b) - -/* GMSD_SET(a,b): a = numeric gmsd field, b = numeric source */ -#define GMSD_SET(a,b) if (gmsd) {gmsd->a = (b); gmsd->flags.a = 1; } - -/* GMSD_UNSET(a): a = gmsd field */ -#define GMSD_UNSET(a) if (gmsd) { gmsd->flags.a = 0; } - -/* GMSD_SETSTR(a,b): a = gmsd field, b = null terminated source */ -#define GMSD_SETSTR(a,b) if (gmsd && (b) && (b)[0]) { gmsd->a = xstrdup((b)); gmsd->flags.a = 1; } -#define GMSD_SETQSTR(a,b) if (gmsd) { gmsd->a = xstrdup((b)); gmsd->flags.a = 1; } -#define GMSD_SETSTRQ(a,b) if (gmsd && !b.isEmpty()) { gmsd->a = xstrdup((b)); gmsd->flags.a = 1; } - -/* GMSD_SETNSTR(a,b,c): a = gmsd field, b = source, c = sizeof(source) */ -#define GMSD_SETNSTR(a,b,c) if (gmsd && (b) && (b)[0]) { gmsd->a = xstrndup((b),(c)); gmsd->flags.a = 1; } - -/* GMSD_GETNSTR(a,b,c): a = gmsd field, b = target, c = sizeof(target) */ -#define GMSD_GETNSTR(a,b,c) if (gmsd && gmsd->flags.a) strncpy((b),gmsd->a,(c)) - struct garmin_ilink_t { int ref_count; double lat, lon, alt; @@ -67,6 +42,29 @@ struct garmin_ilink_t { }; struct garmin_fs_flags_t { +public: + garmin_fs_flags_t() : + icon(0), + wpt_class(0), + display(0), + category(0), + city(0), + state(0), + facility(0), + cc(0), + cross_road(0), + addr(0), + country(0), + phone_nr(0), + phone_nr2(0), + fax_nr(0), + postal_code(0), + email(0) +#ifdef GMSD_EXPERIMENTAL + , subclass(0) +#endif + {} + unsigned int icon:1; unsigned int wpt_class:1; unsigned int display:1; @@ -88,32 +86,120 @@ struct garmin_fs_flags_t { #endif }; -struct garmin_fs_t { +class garmin_fs_t { +public: format_specific_data fs; garmin_fs_flags_t flags; - int protocol; /* ... used by device (-1 is MapSource) */ - - int32_t icon; - int wpt_class; - int32_t display; - int16_t category; - char* city; /* city name */ - char* facility; /* facility name */ - char* state; /* state */ - char* cc; /* country code */ - char* cross_road; /* Intersection road label */ - char* addr; /* address + number */ - char* country; /* country */ - char* phone_nr; /* phone number */ - char* phone_nr2; /* phone number (2) */ - char* fax_nr; /* fax number */ - char* postal_code; /* postal code */ - char* email; /* email address */ - garmin_ilink_t* ilinks; + int protocol{0}; /* ... used by device (-1 is MapSource) */ + + int32_t icon{0}; + int wpt_class{0}; + int32_t display{0}; + int16_t category{0}; + QString city; /* city name */ + QString facility; /* facility name */ + QString state; /* state */ + QString cc; /* country code */ + QString cross_road; /* Intersection road label */ + QString addr; /* address + number */ + QString country; /* country */ + QString phone_nr; /* phone number */ + QString phone_nr2; /* phone number (2) */ + QString fax_nr; /* fax number */ + QString postal_code; /* postal code */ + QString email; /* email address */ + garmin_ilink_t* ilinks{nullptr}; #ifdef GMSD_EXPERIMENTAL - char subclass[22]; + char subclass[22]{}; #endif + +public: + garmin_fs_t() = default; + ~garmin_fs_t(); + garmin_fs_t(const garmin_fs_t& other); + garmin_fs_t& operator=(const garmin_fs_t& rhs) = delete; /* not implemented */ + garmin_fs_t(garmin_fs_t&&) = delete; /* not implemented */ + garmin_fs_t& operator=(garmin_fs_t&&) = delete; /* not implemented */ + + static garmin_fs_t* find(const Waypoint* wpt) { + return (garmin_fs_t*) fs_chain_find(wpt->fs, FS_GMSD); + } + +#define GEN_GMSD_METHODS(field) \ + static bool has_##field(const garmin_fs_t* gmsd) \ + { \ + return gmsd && gmsd->flags.field; \ + } \ + static decltype(field) get_##field(const garmin_fs_t* gmsd, decltype(field) p) \ + { \ + return (gmsd && gmsd->flags.field)? gmsd->field : p; \ + } \ + static void set_##field(garmin_fs_t* gmsd, decltype(field) p) \ + { \ + if (gmsd) { \ + gmsd->field = p; \ + gmsd->flags.field = 1; \ + } \ + } \ + static void unset_##field(garmin_fs_t* gmsd) \ + { \ + if (gmsd) { \ + gmsd->flags.field = 0; \ + } \ + } + + GEN_GMSD_METHODS(icon) + GEN_GMSD_METHODS(wpt_class) + GEN_GMSD_METHODS(display) + GEN_GMSD_METHODS(category) + +#undef GEN_GMSD_METHODS + +#define GEN_GMSD_STR_METHODS(field) \ + static bool has_##field(const garmin_fs_t* gmsd) \ + { \ + return gmsd && gmsd->flags.field; \ + } \ + static QString get_##field(const garmin_fs_t* gmsd, const QString& p) \ + { \ + return (gmsd && gmsd->flags.field)? gmsd->field : p; \ + } \ + static void set_##field(garmin_fs_t* gmsd, const char* p) \ + { \ + if (gmsd && p && *p) { \ + gmsd->field = p; \ + gmsd->flags.field = 1; \ + } \ + } \ + static void set_##field(garmin_fs_t* gmsd, const QString& p) \ + { \ + if (gmsd && !p.isEmpty()) { \ + gmsd->field = p; \ + gmsd->flags.field = 1; \ + } \ + } \ + static void unset_##field(garmin_fs_t* gmsd) \ + { \ + if (gmsd) { \ + gmsd->flags.field = 0; \ + } \ + } + + GEN_GMSD_STR_METHODS(city) + GEN_GMSD_STR_METHODS(facility) + GEN_GMSD_STR_METHODS(state) + GEN_GMSD_STR_METHODS(cc) + GEN_GMSD_STR_METHODS(cross_road) + GEN_GMSD_STR_METHODS(addr) + GEN_GMSD_STR_METHODS(country) + GEN_GMSD_STR_METHODS(phone_nr) + GEN_GMSD_STR_METHODS(phone_nr2) + GEN_GMSD_STR_METHODS(fax_nr) + GEN_GMSD_STR_METHODS(postal_code) + GEN_GMSD_STR_METHODS(email) + +#undef GEN_GMSD_STR_METHODS }; using garmin_fs_p = garmin_fs_t*; @@ -124,7 +210,7 @@ void garmin_fs_convert(void* fs); char* garmin_fs_xstrdup(const char* src, size_t size); /* for GPX */ -void garmin_fs_xml_convert(int base_tag, int tag, const QString& cdatastr, Waypoint* waypt); +void garmin_fs_xml_convert(int base_tag, int tag, const QString& qstr, Waypoint* waypt); class QXmlStreamWriter; void garmin_fs_xml_fprint(const Waypoint* waypt, QXmlStreamWriter*); diff --git a/garmin_gpi.cc b/garmin_gpi.cc index fb2c5ada5..803f78b39 100644 --- a/garmin_gpi.cc +++ b/garmin_gpi.cc @@ -209,16 +209,15 @@ struct gpi_bitmap_header_t { }; struct gpi_waypt_t { - int sz; - int alerts; - short mask; - char addr_is_dynamic; - char* addr; - char* city; - char* country; - char* phone_nr; - char* postal_code; - char* state; + int sz{0}; + int alerts{0}; + short mask{0}; + QString addr; + QString city; + QString country; + QString phone_nr; + QString postal_code; + QString state; }; static gbfile* fin, *fout; @@ -244,7 +243,7 @@ static time_t gpi_timestamp = 0; static garmin_fs_t* gpi_gmsd_init(Waypoint* wpt) { - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); if (wpt == nullptr) { fatal(MYNAME ": Error in file structure.\n"); } @@ -561,7 +560,6 @@ read_tag(const char* caller, const int tag, Waypoint* wpt) double speed; short mask; QString str; - char* cstr; garmin_fs_t* gmsd; int sz = gbfgetint32(fin); @@ -664,45 +662,45 @@ read_tag(const char* caller, const int tag, Waypoint* wpt) #ifdef GPI_DBG dbginfo("GPI Address field mask: %d (0x%02x)\n", mask, mask); #endif - if ((mask & GPI_ADDR_CITY) && (cstr = gpi_read_string_old("City"))) { + if ((mask & GPI_ADDR_CITY) && !(str = gpi_read_string("City")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(city, cstr); + garmin_fs_t::set_city(gmsd, str); } - if ((mask & GPI_ADDR_COUNTRY) && (cstr = gpi_read_string_old("Country"))) { + if ((mask & GPI_ADDR_COUNTRY) && !(str = gpi_read_string("Country")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(country, cstr); + garmin_fs_t::set_country(gmsd, str); } - if ((mask & GPI_ADDR_STATE) && (cstr = gpi_read_string_old("State"))) { + if ((mask & GPI_ADDR_STATE) && !(str = gpi_read_string("State")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(state, cstr); + garmin_fs_t::set_state(gmsd, str); } - if ((mask & GPI_ADDR_POSTAL_CODE) && (cstr = gpi_read_string_old("Postal code"))) { + if ((mask & GPI_ADDR_POSTAL_CODE) && !(str = gpi_read_string("Postal code")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(postal_code, cstr); + garmin_fs_t::set_postal_code(gmsd, str); } - if ((mask & GPI_ADDR_ADDR) && (cstr = gpi_read_string_old("Street address"))) { + if ((mask & GPI_ADDR_ADDR) && !(str = gpi_read_string("Street address")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(addr, cstr); + garmin_fs_t::set_addr(gmsd, str); } break; case 0xc: mask = gbfgetint16(fin); - if ((mask & 1) && (cstr = gpi_read_string_old("Phone"))) { + if ((mask & 1) && !(str = gpi_read_string("Phone")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(phone_nr, cstr); + garmin_fs_t::set_phone_nr(gmsd, str); } - if ((mask & 2) && (cstr = gpi_read_string_old("Phone2"))) { + if ((mask & 2) && !(str = gpi_read_string("Phone2")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(phone_nr2, cstr); + garmin_fs_t::set_phone_nr2(gmsd, str); } - if ((mask & 4) && (cstr = gpi_read_string_old("Fax"))) { + if ((mask & 4) && !(str = gpi_read_string("Fax")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(fax_nr, cstr); + garmin_fs_t::set_fax_nr(gmsd, str); } - if ((mask & 8) && (cstr = gpi_read_string_old("Email"))) { + if ((mask & 8) && !(str = gpi_read_string("Email")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(email, cstr); + garmin_fs_t::set_email(gmsd, str); } if ((mask & 0x10) && (str = gpi_read_string("Link"), !str.isEmpty())) { waypt_add_url(wpt, str, str); @@ -717,9 +715,9 @@ read_tag(const char* caller, const int tag, Waypoint* wpt) #ifdef GPI_DBG dbginfo("GPI Phone field mask: %d (0x%02x)\n", mask, mask); #endif - if ((mask & 1) && (cstr = gpi_read_string_old("Phone"))) { + if ((mask & 1) && !(str = gpi_read_string("Phone")).isEmpty()) { gmsd = gpi_gmsd_init(wpt); - GMSD_SET(phone_nr, cstr); + garmin_fs_t::set_phone_nr(gmsd, str); } break; @@ -804,10 +802,7 @@ wdata_free(writer_data_t* data) if (wpt->extra_data) { gpi_waypt_t* dt = (gpi_waypt_t*) wpt->extra_data; - if (dt->addr_is_dynamic) { - xfree(dt->addr); - } - xfree(dt); + delete dt; } delete wpt; } @@ -923,7 +918,7 @@ wdata_compute_size(writer_data_t* data) res += 10; /* tag(4) */ } - gpi_waypt_t* dt = (gpi_waypt_t*) xcalloc(1, sizeof(*dt)); + gpi_waypt_t* dt = new gpi_waypt_t; wpt->extra_data = dt; if (alerts) { @@ -961,7 +956,7 @@ wdata_compute_size(writer_data_t* data) } } - QString str = QString(); + QString str; if (opt_descr) { if (!wpt->description.isEmpty()) { str = wpt->description; @@ -976,36 +971,35 @@ wdata_compute_size(writer_data_t* data) if (!str.isEmpty()) { - dt->addr_is_dynamic = 1; - dt->addr = xstrdup(str); + dt->addr = str; dt->mask |= GPI_ADDR_ADDR; - dt->sz += (8 + strlen(dt->addr)); + dt->sz += (8 + strlen(STRFROMUNICODE(dt->addr))); } - if ((gmsd = GMSD_FIND(wpt))) { - if ((dt->mask == 0) && ((dt->addr = GMSD_GET(addr, NULL)))) { + if ((gmsd = garmin_fs_t::find(wpt))) { + if ((dt->mask == 0) && !(dt->addr = garmin_fs_t::get_addr(gmsd, nullptr)).isEmpty()) { dt->mask |= GPI_ADDR_ADDR; - dt->sz += (8 + strlen(dt->addr)); + dt->sz += (8 + strlen(STRFROMUNICODE(dt->addr))); } - if ((dt->city = GMSD_GET(city, NULL))) { + if (!(dt->city = garmin_fs_t::get_city(gmsd, nullptr)).isEmpty()) { dt->mask |= GPI_ADDR_CITY; - dt->sz += (8 + strlen(dt->city)); + dt->sz += (8 + strlen(STRFROMUNICODE(dt->city))); } - if ((dt->country = GMSD_GET(country, NULL))) { + if (!(dt->country = garmin_fs_t::get_country(gmsd, nullptr)).isEmpty()) { dt->mask |= GPI_ADDR_COUNTRY; - dt->sz += (8 + strlen(dt->country)); + dt->sz += (8 + strlen(STRFROMUNICODE(dt->country))); } - if ((dt->state = GMSD_GET(state, NULL))) { + if (!(dt->state = garmin_fs_t::get_state(gmsd, nullptr)).isEmpty()) { dt->mask |= GPI_ADDR_STATE; - dt->sz += (8 + strlen(dt->state)); + dt->sz += (8 + strlen(STRFROMUNICODE(dt->state))); } - if ((dt->postal_code = GMSD_GET(postal_code, NULL))) { + if (!(dt->postal_code = garmin_fs_t::get_postal_code(gmsd, nullptr)).isEmpty()) { dt->mask |= GPI_ADDR_POSTAL_CODE; - dt->sz += (2 + strlen(dt->postal_code)); /* short form */ + dt->sz += (2 + strlen(STRFROMUNICODE(dt->postal_code))); /* short form */ } - if ((dt->phone_nr = GMSD_GET(phone_nr, NULL))) { - res += (12 + 4 + strlen(dt->phone_nr)); + if (!(dt->phone_nr = garmin_fs_t::get_phone_nr(gmsd, nullptr)).isEmpty()) { + res += (12 + 4 + strlen(STRFROMUNICODE(dt->phone_nr))); } } if (dt->mask) { @@ -1090,8 +1084,8 @@ wdata_write(const writer_data_t* data) if (dt->sz) { s0 += (12 + dt->sz); /* address part */ } - if (dt->phone_nr) { - s0 += (12 + 4 + strlen(dt->phone_nr)); + if (!dt->phone_nr.isEmpty()) { + s0 += (12 + 4 + strlen(STRFROMUNICODE(dt->phone_nr))); } if (dt->alerts) { s0 += 20; /* tag(3) */ @@ -1152,28 +1146,28 @@ wdata_write(const writer_data_t* data) gbfputint32(0x2, fout); /* ? always 2 ? */ gbfputint16(dt->mask, fout); if (dt->mask & GPI_ADDR_CITY) { - write_string(dt->city, 1); + write_string(STRFROMUNICODE(dt->city), 1); } if (dt->mask & GPI_ADDR_COUNTRY) { - write_string(dt->country, 1); + write_string(STRFROMUNICODE(dt->country), 1); } if (dt->mask & GPI_ADDR_STATE) { - write_string(dt->state, 1); + write_string(STRFROMUNICODE(dt->state), 1); } if (dt->mask & GPI_ADDR_POSTAL_CODE) { - write_string(dt->postal_code, 0); + write_string(STRFROMUNICODE(dt->postal_code), 0); } if (dt->mask & GPI_ADDR_ADDR) { - write_string(dt->addr, 1); + write_string(STRFROMUNICODE(dt->addr), 1); } } - if (dt->phone_nr) { + if (!dt->phone_nr.isEmpty()) { gbfputint32(0x8000c, fout); - gbfputint32(strlen(dt->phone_nr) + 2 + 2, fout); + gbfputint32(strlen(STRFROMUNICODE(dt->phone_nr)) + 2 + 2, fout); gbfputint32(0x2, fout); /* ? always 2 ? */ gbfputint16(1, fout); /* mask */ - write_string(dt->phone_nr, 0); + write_string(STRFROMUNICODE(dt->phone_nr), 0); } } diff --git a/garmin_txt.cc b/garmin_txt.cc index 3749a289d..b05283e93 100644 --- a/garmin_txt.cc +++ b/garmin_txt.cc @@ -215,8 +215,8 @@ convert_datum(const Waypoint* wpt, double* dest_lat, double* dest_lon) static void enum_waypt_cb(const Waypoint* wpt) { - garmin_fs_p gmsd = GMSD_FIND(wpt); - int wpt_class = GMSD_GET(wpt_class, 0); + garmin_fs_p gmsd = garmin_fs_t::find(wpt); + int wpt_class = garmin_fs_t::get_wpt_class(gmsd, 0); if (wpt_class < 0x80) { if (gtxt_flags.enum_waypoints) { /* enumerate only */ waypoints++; @@ -535,15 +535,15 @@ write_waypt(const Waypoint* wpt) { const char* wpt_type; - garmin_fs_p gmsd = GMSD_FIND(wpt); + garmin_fs_p gmsd = garmin_fs_t::find(wpt); - int i = GMSD_GET(display, 0); + int i = garmin_fs_t::get_display(gmsd, 0); if (i > GT_DISPLAY_MODE_MAX) { i = 0; } const char* dspl_mode = gt_display_mode_names[i]; - unsigned char wpt_class = GMSD_GET(wpt_class, 0); + unsigned char wpt_class = garmin_fs_t::get_wpt_class(gmsd, 0); if (wpt_class <= gt_waypt_class_map_line) { wpt_type = gt_waypt_class_names[wpt_class]; } else { @@ -593,16 +593,16 @@ write_waypt(const Waypoint* wpt) *fout << "Unknown\t"; /* Color is fixed: Unknown */ - int icon = GMSD_GET(icon, -1); + int icon = garmin_fs_t::get_icon(gmsd, -1); if (icon == -1) { icon = gt_find_icon_number_from_desc(wpt->icon_descr, GDB); } print_string("%s\t", gt_find_desc_from_icon_number(icon, GDB)); - print_string("%s\t", GMSD_GET(facility, "")); - print_string("%s\t", GMSD_GET(city, "")); - print_string("%s\t", GMSD_GET(state, "")); - const char* country = gt_get_icao_country(GMSD_GET(cc, "")); + print_string("%s\t", garmin_fs_t::get_facility(gmsd, "")); + print_string("%s\t", garmin_fs_t::get_city(gmsd, "")); + print_string("%s\t", garmin_fs_t::get_state(gmsd, "")); + const char* country = gt_get_icao_country(garmin_fs_t::get_cc(gmsd, "")); print_string("%s\t", (country != nullptr) ? country : ""); print_date_and_time(wpt->GetCreationTime().toTime_t(), 0); if (wpt->HasUrlLink()) { @@ -611,7 +611,7 @@ write_waypt(const Waypoint* wpt) } else { print_string("%s\t", ""); } - print_categories(GMSD_GET(category, 0)); + print_categories(garmin_fs_t::get_category(gmsd, 0)); *fout << "\r\n"; } @@ -1108,7 +1108,7 @@ parse_waypoint() case 3: for (i = 0; i <= gt_waypt_class_map_line; i++) { if (case_ignore_strcmp(str, gt_waypt_class_names[i]) == 0) { - GMSD_SET(wpt_class, i); + garmin_fs_t::set_wpt_class(gmsd, i); break; } } @@ -1139,28 +1139,28 @@ parse_waypoint() break; case 9: if (parse_display(str, &i)) { - GMSD_SET(display, i); + garmin_fs_t::set_display(gmsd, i); } break; case 10: break; /* skip color */ case 11: i = gt_find_icon_number_from_desc(str, GDB); - GMSD_SET(icon, i); + garmin_fs_t::set_icon(gmsd, i); wpt->icon_descr = gt_find_desc_from_icon_number(i, GDB); break; case 12: - GMSD_SETSTR(facility, str); + garmin_fs_t::set_facility(gmsd, str); break; case 13: - GMSD_SETSTR(city, str); + garmin_fs_t::set_city(gmsd, str); break; case 14: - GMSD_SETSTR(state, str); + garmin_fs_t::set_state(gmsd, str); break; case 15: - GMSD_SETSTR(country, str); - GMSD_SETSTR(cc, gt_get_icao_cc(str, wpt->shortname)); + garmin_fs_t::set_country(gmsd, str); + garmin_fs_t::set_cc(gmsd, gt_get_icao_cc(str, wpt->shortname)); break; case 16: { time_t ct; @@ -1174,7 +1174,7 @@ parse_waypoint() } break; case 18: - GMSD_SET(category, parse_categories(str)); + garmin_fs_t::set_category(gmsd, parse_categories(str)); break; default: break; diff --git a/gdb.cc b/gdb.cc index 97f5ccc65..a5106f642 100644 --- a/gdb.cc +++ b/gdb.cc @@ -422,13 +422,12 @@ static Waypoint* read_waypoint(gt_waypt_classes_e* waypt_class_out) { char buf[128]; /* used for temporary stuff */ - QByteArray ba; int display, icon; gt_waypt_classes_e wpt_class; int i; Waypoint* res; garmin_fs_t* gmsd; - char* str; + QString str; #ifdef GMSD_EXPERIMENTAL char subclass[22]; #endif @@ -439,13 +438,12 @@ read_waypoint(gt_waypt_classes_e* waypt_class_out) fs_chain_add(&res->fs, (format_specific_data*) gmsd); res->shortname = fread_cstr(); wpt_class = (gt_waypt_classes_e) FREAD_i32; - GMSD_SET(wpt_class, wpt_class); + garmin_fs_t::set_wpt_class(gmsd, wpt_class); if (wpt_class != 0) { waypth_ct++; } - ba = FREAD_STR(); /* Country code */ - GMSD_SETSTR(cc, ba.constData()); + garmin_fs_t::set_cc(gmsd, fread_cstr()); #ifdef GMSD_EXPERIMENTAL FREAD(subclass, sizeof(subclass)); @@ -509,17 +507,14 @@ read_waypoint(gt_waypt_classes_e* waypt_class_out) display = gt_display_mode_symbol_and_name; break; } - GMSD_SET(display, display); + garmin_fs_t::set_display(gmsd, display); FREAD_i32; /* color !not implemented! */ icon = FREAD_i32; - GMSD_SET(icon, icon); /* icon */ - ba = FREAD_STR(); /* city */ - GMSD_SETSTR(city, ba.constData()); - ba = FREAD_STR(); /* state */ - GMSD_SETSTR(state, ba.constData()); - ba = FREAD_STR(); /* facility */ - GMSD_SETSTR(facility, ba.constData()); + garmin_fs_t::set_icon(gmsd, icon); + garmin_fs_t::set_city(gmsd, fread_cstr()); + garmin_fs_t::set_state(gmsd, fread_cstr()); + garmin_fs_t::set_facility(gmsd, fread_cstr()); FREAD(buf, 1); @@ -565,8 +560,7 @@ read_waypoint(gt_waypt_classes_e* waypt_class_out) waypt_flag = 0; - ba = FREAD_STR(); /* street address */ - GMSD_SETSTR(addr, ba.constData()); + garmin_fs_t::set_addr(gmsd, fread_cstr()); FREAD(buf, 5); /* instruction depended */ res->description = FREAD_CSTR_AS_QSTR; /* instruction */ @@ -594,7 +588,7 @@ read_waypoint(gt_waypt_classes_e* waypt_class_out) #endif i = FREAD_i16; if (i != 0) { - GMSD_SET(category, i); + garmin_fs_t::set_category(gmsd, i); } #if GDB_DEBUG DBG(GDB_DBG_WPTe, i) @@ -624,14 +618,11 @@ read_waypoint(gt_waypt_classes_e* waypt_class_out) /* VERSION DEPENDENT CODE */ if (gdb_ver >= GDB_VER_3) { if (FREAD_i32 == 1) { - ba = FREAD_STR(); /* phone number */ - GMSD_SETSTR(phone_nr, ba.constData()); + garmin_fs_t::set_phone_nr(gmsd, fread_cstr()); (void) FREAD_STR(); /* ?? fax / mobile ?? */ } - ba = FREAD_STR(); /* country */ - GMSD_SETSTR(country, ba.constData()); - ba = FREAD_STR(); /* postal code */ - GMSD_SETSTR(postal_code, ba.constData()); + garmin_fs_t::set_country(gmsd, fread_cstr()); + garmin_fs_t::set_postal_code(gmsd, fread_cstr()); } res->icon_descr = gt_find_desc_from_icon_number(icon, GDB); @@ -641,16 +632,16 @@ read_waypoint(gt_waypt_classes_e* waypt_class_out) printf(MYNAME "-wpt \"%s\" (%d): icon = \"%s\" (MapSource symbol %d)\n", qPrintable(res->shortname), wpt_class, qPrintable(res->icon_descr), icon); #endif - if ((str = GMSD_GET(cc, NULL))) { - if (! GMSD_HAS(country)) { - GMSD_SETSTR(country, gt_get_icao_country(str)); + if (!(str = garmin_fs_t::get_cc(gmsd, nullptr)).isEmpty()) { + if (! (garmin_fs_t::has_country(gmsd))) { + garmin_fs_t::set_country(gmsd, gt_get_icao_country(str)); } } if (gdb_roadbook && (wpt_class > gt_waypt_class_map_point) && !res->description.isEmpty()) { wpt_class = gt_waypt_class_user_waypoint; - GMSD_SET(wpt_class, wpt_class); + garmin_fs_t::set_wpt_class(gmsd, wpt_class); #ifdef GMSD_EXPERIMENTAL - GMSD_UNSET(subclass); + garmin_fs_t::unset_subclass(gmsd); #endif } *waypt_class_out = wpt_class; @@ -822,12 +813,12 @@ read_route() #endif wpt = gdb_add_route_waypt(rte, wpt, wpt_class); if (wpt != nullptr) { - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); if (gmsd == nullptr) { gmsd = garmin_fs_alloc(-1); fs_chain_add(&wpt->fs, (format_specific_data*) gmsd); } - GMSD_SET(wpt_class, wpt_class); + garmin_fs_t::set_wpt_class(gmsd, wpt_class); gmsd->ilinks = il_root; il_root = nullptr; } @@ -1215,7 +1206,7 @@ write_waypoint( FWRITE_CSTR(shortname); /* unique (!!!) shortname */ FWRITE_i32(wpt_class); /* waypoint class */ - FWRITE_CSTR(GMSD_GET(cc, "")); /* country code */ + FWRITE_CSTR(garmin_fs_t::get_cc(gmsd, "")); /* country code */ if (wpt_class != 0) { waypth_ct++; @@ -1245,9 +1236,9 @@ write_waypoint( FWRITE_i32(display); /* display */ FWRITE_i32(0); /* color */ FWRITE_i32(icon); /* icon */ - FWRITE_CSTR(GMSD_GET(city, "")); /* city */ - FWRITE_CSTR(GMSD_GET(state, "")); /* state */ - FWRITE_CSTR(GMSD_GET(facility, "")); /* facility */ + FWRITE_CSTR(garmin_fs_t::get_city(gmsd, "")); /* city */ + FWRITE_CSTR(garmin_fs_t::get_state(gmsd, "")); /* state */ + FWRITE_CSTR(garmin_fs_t::get_facility(gmsd, "")); /* facility */ FWRITE_C(0); /* unknown */ FWRITE_DBL(WAYPT_GET(wpt, depth, unknown_alt), unknown_alt); /* depth */ @@ -1273,7 +1264,7 @@ write_waypoint( QString str; if (wpt_class < gt_waypt_class_map_point) { /* street address */ - str = GMSD_GET(addr, ""); + str = garmin_fs_t::get_addr(gmsd, ""); } else { str = ""; } @@ -1308,22 +1299,22 @@ write_waypoint( } } - FWRITE_i16(GMSD_GET(category, gdb_category)); + FWRITE_i16(garmin_fs_t::get_category(gmsd, gdb_category)); FWRITE_DBL(WAYPT_GET(wpt, temperature, 0), 0); FWRITE_TIME(wpt->GetCreationTime().toTime_t()); /* VERSION DEPENDENT CODE */ if (gdb_ver >= GDB_VER_3) { - const char* str = GMSD_GET(phone_nr, ""); - if (*str) { + QString str = garmin_fs_t::get_phone_nr(gmsd, ""); + if (!str.isEmpty()) { FWRITE_i32(1); FWRITE_CSTR(str); FWRITE_CSTR(""); } else { FWRITE_i32(0); } - FWRITE_CSTR(GMSD_GET(country, "")); - FWRITE_CSTR(GMSD_GET(postal_code, "")); + FWRITE_CSTR(garmin_fs_t::get_country(gmsd, "")); + FWRITE_CSTR(garmin_fs_t::get_postal_code(gmsd, "")); } } @@ -1398,7 +1389,7 @@ write_route(const route_head* rte, const QString& rte_name) fatal(MYNAME ": Sorry, that should never happen!!!\n"); } - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); /* extra_data may contain a modified shortname */ FWRITE_CSTR((wpt->extra_data) ? (char*)wpt->extra_data : wpt->shortname); @@ -1406,7 +1397,7 @@ write_route(const route_head* rte, const QString& rte_name) int wpt_class = wpt->wpt_flags.fmt_use; /* trick */ FWRITE_i32(wpt_class); /* waypoint class */ - FWRITE_CSTR(GMSD_GET(cc, "")); /* country */ + FWRITE_CSTR(garmin_fs_t::get_cc(gmsd, "")); /* country */ #ifdef GMSD_EXPERIMENTAL if (gmsd && gmsd->flags.subclass && (wpt_class >= gt_waypt_class_map_point)) { FWRITE(gmsd->subclass, sizeof(gmsd->subclass)); @@ -1571,15 +1562,15 @@ write_waypoint_cb(const Waypoint* refpt) fout = ftmp; /* prepare the waypoint */ - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); - int wpt_class = GMSD_GET(wpt_class, -1); + int wpt_class = garmin_fs_t::get_wpt_class(gmsd, -1); if (wpt_class == -1) { wpt_class = (route_flag) ? GDB_DEF_HIDDEN_CLASS : GDB_DEF_CLASS; } wpt->wpt_flags.fmt_use = wpt_class; /* trick, we need this for the route(s) */ - int icon = GMSD_GET(icon, -1); + int icon = garmin_fs_t::get_icon(gmsd, -1); if (icon < 0) { if (wpt->icon_descr.isNull()) { icon = GDB_DEF_ICON; @@ -1588,7 +1579,7 @@ write_waypoint_cb(const Waypoint* refpt) } } - switch (GMSD_GET(display, -1)) { /* display */ + switch (garmin_fs_t::get_display(gmsd, -1)) { /* display */ case -1: if (wpt_class < 8) { display = gt_gdb_display_mode_symbol_and_name; diff --git a/gpx.cc b/gpx.cc index c034a6637..d6809c31a 100644 --- a/gpx.cc +++ b/gpx.cc @@ -1411,7 +1411,7 @@ GpxFormat::gpx_waypt_pr(const Waypoint* waypointp) if (!(opt_humminbirdext || opt_garminext)) { auto* fs_gpx = (fs_xml*)fs_chain_find(waypointp->fs, FS_GPX); - auto* gmsd = GMSD_FIND(waypointp); /* gARmIN sPECIAL dATA */ + auto* gmsd = garmin_fs_t::find(waypointp); /* gARmIN sPECIAL dATA */ if (fs_gpx) { if (! gmsd) { fprint_xml_chain(fs_gpx->tag, waypointp); diff --git a/lowranceusr.cc b/lowranceusr.cc index af9b8d0d3..87eb8a593 100644 --- a/lowranceusr.cc +++ b/lowranceusr.cc @@ -416,7 +416,6 @@ lowranceusr4_alloc_fsdata() fsdata->fs.type = FS_LOWRANCEUSR4; fsdata->fs.copy = (fs_copy) lowranceusr4_copy_fsdata; fsdata->fs.destroy = lowranceusr4_free_fsdata; - fsdata->fs.convert = nullptr; fsdata->uid_unit = 0; fsdata->uid_seq_low = 0; diff --git a/main.cc b/main.cc index 953c5687f..9d55cfce0 100644 --- a/main.cc +++ b/main.cc @@ -43,7 +43,7 @@ #endif #include "defs.h" -#include "cet_util.h" // for cet_convert_init, cet_convert_strings, cet_convert_deinit, cet_deregister, cet_register, cet_cs_vec_utf8 +#include "cet_util.h" // for cet_convert_init, cet_convert_deinit, cet_deregister, cet_register, cet_cs_vec_utf8 #include "csv_util.h" // for csv_linesplit #include "filter.h" // for Filter #include "filter_vecs.h" // for FilterVecs @@ -305,7 +305,6 @@ run(const char* prog_name) ivecs->read(); ivecs->rd_deinit(); - cet_convert_strings(global_opts.charset, nullptr); cet_convert_deinit(); did_something = true; @@ -345,7 +344,6 @@ run(const char* prog_name) route_backup(&rte_head_bak); track_backup(&trk_head_bak); - cet_convert_strings(nullptr, global_opts.charset); global_opts.verbose_status = saved_status; } @@ -533,12 +531,10 @@ run(const char* prog_name) ivecs->read(); ivecs->rd_deinit(); - cet_convert_strings(global_opts.charset, nullptr); cet_convert_deinit(); if (qargs.size() == 2 && ovecs) { cet_convert_init(ovecs->get_encode(), 1); - cet_convert_strings(nullptr, global_opts.charset); ovecs->wr_init(qargs.at(1)); ovecs->write(); @@ -558,7 +554,6 @@ run(const char* prog_name) int saved_status = global_opts.verbose_status; global_opts.verbose_status = 0; cet_convert_init(CET_CHARSET_ASCII, 1); - cet_convert_strings(nullptr, global_opts.charset); waypt_disp_all(waypt_disp); global_opts.verbose_status = saved_status; } diff --git a/ozi.cc b/ozi.cc index 9f15409f1..cfcbf5c41 100644 --- a/ozi.cc +++ b/ozi.cc @@ -192,7 +192,6 @@ ozi_alloc_fsdata() fsdata->fs.type = FS_OZI; fsdata->fs.copy = (fs_copy) ozi_copy_fsdata; fsdata->fs.destroy = ozi_free_fsdata; - fsdata->fs.convert = nullptr; /* Provide defaults via command line defaults */ fsdata->fgcolor = color_to_bbggrr(wptfgcolor); diff --git a/random.cc b/random.cc index adc6c7dbd..fd14816d3 100644 --- a/random.cc +++ b/random.cc @@ -86,15 +86,15 @@ rand_int(const int max) /* rand_str always returns a valid string with len >= 0 */ -static char* +static QString rand_str(const int maxlen, const char* fmt) { int len = rand_int(maxlen) + 1; - auto res = (char*) xmalloc(len + 1); - res[len] = '\0'; + QByteArray res; + res.resize(len); - for (int i = 0; i < len; i++) { + for (int i = 0; i < len; ++i) { int c = rand_int(26 + 26 + 10); if (c < 26) { c += 'a'; @@ -105,23 +105,8 @@ rand_str(const int maxlen, const char* fmt) } res[i] = c; } - if (fmt) { - char* tmp; - xasprintf(&tmp, fmt, res); - xfree(res); - return tmp; - } else { - return res; - } -} - -static QString -rand_qstr(const int maxlen, const char* fmt) -{ - char * str = rand_str(maxlen, fmt); - QString qstr = QString(str); - xfree(str); - return qstr; + return (fmt != nullptr)? + QString::asprintf(fmt, res.constData()) : QString(res); } static void @@ -157,7 +142,7 @@ random_generate_wpt(int i, const QDateTime& time, const Waypoint* prev) fs_chain_add(&wpt->fs, (format_specific_data*) gmsd); do { - wpt->shortname = rand_qstr(8, "Wpt_%s"); + wpt->shortname = rand_str(8, "Wpt_%s"); } while (wpt->shortname == nullptr); wpt->latitude = rand_dbl(180.0) - 90.0; @@ -178,13 +163,13 @@ random_generate_wpt(int i, const QDateTime& time, const Waypoint* prev) WAYPT_SET(wpt, depth, rand_dbl(1000.0)); } if RND(3) { - wpt->AddUrlLink(rand_qstr(8, "http://link1.example.com/%s")); + wpt->AddUrlLink(rand_str(8, "http://link1.example.com/%s")); if RND(3) { - wpt->AddUrlLink(rand_qstr(8, "http://link2.example.com/%s")); + wpt->AddUrlLink(rand_str(8, "http://link2.example.com/%s")); } } if RND(3) { - wpt->icon_descr = rand_qstr(3, "Icon_%s"); + wpt->icon_descr = rand_str(3, "Icon_%s"); } wpt->SetCreationTime(time); @@ -213,31 +198,31 @@ random_generate_wpt(int i, const QDateTime& time, const Waypoint* prev) wpt->longitude = prev->longitude + rand_dbl(0.01); } if RND(3) { - wpt->description = rand_qstr(16, "Des_%s"); + wpt->description = rand_str(16, "Des_%s"); } if RND(3) { - wpt->notes = rand_qstr(16, "Nts_%s"); + wpt->notes = rand_str(16, "Nts_%s"); } if RND(3) { - GMSD_SET(addr, rand_str(8, "Adr_%s")); + garmin_fs_t::set_addr(gmsd, rand_str(8, "Adr_%s")); } if RND(3) { - GMSD_SET(city, rand_str(8, "Cty_%s")); + garmin_fs_t::set_city(gmsd, rand_str(8, "Cty_%s")); } if RND(3) { - GMSD_SET(facility, rand_str(8, "Fac_%s")); + garmin_fs_t::set_facility(gmsd, rand_str(8, "Fac_%s")); } if RND(3) { - GMSD_SET(country, rand_str(8, "Ctr_%s")); + garmin_fs_t::set_country(gmsd, rand_str(8, "Ctr_%s")); } if RND(3) { - GMSD_SET(state, rand_str(8, "Sta_%s")); + garmin_fs_t::set_state(gmsd, rand_str(8, "Sta_%s")); } if RND(3) { - GMSD_SET(phone_nr, rand_str(8, "Pnr_%s")); + garmin_fs_t::set_phone_nr(gmsd, rand_str(8, "Pnr_%s")); } if RND(3) { - GMSD_SET(postal_code, rand_str(8, "Pcd_%s")); + garmin_fs_t::set_postal_code(gmsd, rand_str(8, "Pcd_%s")); } } @@ -256,15 +241,15 @@ random_read() if (doing_trks || doing_rtes) { head = route_head_alloc(); if (doing_trks) { - head->rte_name = rand_qstr(8, "Trk_%s"); + head->rte_name = rand_str(8, "Trk_%s"); track_add_head(head); } else { - head->rte_name = rand_qstr(8, "Rte_%s"); + head->rte_name = rand_str(8, "Rte_%s"); route_add_head(head); } - head->rte_desc = rand_qstr(16, nullptr); + head->rte_desc = rand_str(16, nullptr); if RND(3) { - head->rte_urls.AddUrlLink(UrlLink(rand_qstr(8, "http://rteurl.example.com/%s"))); + head->rte_urls.AddUrlLink(UrlLink(rand_str(8, "http://rteurl.example.com/%s"))); } } else { head = nullptr; diff --git a/unicsv.cc b/unicsv.cc index 9914e04cf..2c75836e4 100644 --- a/unicsv.cc +++ b/unicsv.cc @@ -952,41 +952,41 @@ unicsv_parse_one_line(const QString& ibuf) case fld_garmin_fax_nr: case fld_garmin_email: case fld_garmin_facility: - gmsd = GMSD_FIND(wpt); + gmsd = garmin_fs_t::find(wpt); if (! gmsd) { gmsd = garmin_fs_alloc(-1); fs_chain_add(&wpt->fs, (format_specific_data*) gmsd); } switch (unicsv_fields_tab[column]) { case fld_garmin_city: - GMSD_SETQSTR(city, value); + garmin_fs_t::set_city(gmsd, value); break; case fld_garmin_postal_code: - GMSD_SETQSTR(postal_code, value); + garmin_fs_t::set_postal_code(gmsd, value); break; case fld_garmin_state: - GMSD_SETQSTR(state, value); + garmin_fs_t::set_state(gmsd, value); break; case fld_garmin_country: - GMSD_SETQSTR(country, value); + garmin_fs_t::set_country(gmsd, value); break; case fld_garmin_addr: - GMSD_SETQSTR(addr, value); + garmin_fs_t::set_addr(gmsd, value); break; case fld_garmin_phone_nr: - GMSD_SETQSTR(phone_nr, value); + garmin_fs_t::set_phone_nr(gmsd, value); break; case fld_garmin_phone_nr2: - GMSD_SETQSTR(phone_nr2, value); + garmin_fs_t::set_phone_nr2(gmsd, value); break; case fld_garmin_fax_nr: - GMSD_SETQSTR(fax_nr, value); + garmin_fs_t::set_fax_nr(gmsd, value); break; case fld_garmin_email: - GMSD_SETQSTR(email, value); + garmin_fs_t::set_email(gmsd, value); break; case fld_garmin_facility: - GMSD_SETQSTR(facility, value); + garmin_fs_t::set_facility(gmsd, value); break; default: break; @@ -1269,7 +1269,7 @@ static void unicsv_waypt_enum_cb(const Waypoint* wpt) { const QString& shortname = wpt->shortname; - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); if (!shortname.isEmpty()) { gb_setbit(&unicsv_outp_flags, fld_shortname); @@ -1341,34 +1341,34 @@ unicsv_waypt_enum_cb(const Waypoint* wpt) } if (gmsd) { - if GMSD_HAS(addr) { + if (garmin_fs_t::has_addr(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_addr); } - if GMSD_HAS(city) { + if (garmin_fs_t::has_city(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_city); } - if GMSD_HAS(country) { + if (garmin_fs_t::has_country(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_country); } - if GMSD_HAS(phone_nr) { + if (garmin_fs_t::has_phone_nr(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_phone_nr); } - if GMSD_HAS(phone_nr2) { + if (garmin_fs_t::has_phone_nr2(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_phone_nr2); } - if GMSD_HAS(fax_nr) { + if (garmin_fs_t::has_fax_nr(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_fax_nr); } - if GMSD_HAS(email) { + if (garmin_fs_t::has_email(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_email); } - if GMSD_HAS(postal_code) { + if (garmin_fs_t::has_postal_code(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_postal_code); } - if GMSD_HAS(state) { + if (garmin_fs_t::has_state(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_state); } - if GMSD_HAS(facility) { + if (garmin_fs_t::has_facility(gmsd)) { gb_setbit(&unicsv_outp_flags, fld_garmin_facility); } } @@ -1424,7 +1424,7 @@ unicsv_waypt_disp_cb(const Waypoint* wpt) unicsv_waypt_ct++; QString shortname = wpt->shortname; - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); if (unicsv_datum_idx == DATUM_WGS84) { lat = wpt->latitude; @@ -1696,34 +1696,34 @@ unicsv_waypt_disp_cb(const Waypoint* wpt) } if FIELD_USED(fld_garmin_facility) { - unicsv_print_str(GMSD_GET(facility, NULL)); + unicsv_print_str(garmin_fs_t::get_facility(gmsd, nullptr)); } if FIELD_USED(fld_garmin_addr) { - unicsv_print_str(GMSD_GET(addr, NULL)); + unicsv_print_str(garmin_fs_t::get_addr(gmsd, nullptr)); } if FIELD_USED(fld_garmin_city) { - unicsv_print_str(GMSD_GET(city, NULL)); + unicsv_print_str(garmin_fs_t::get_city(gmsd, nullptr)); } if FIELD_USED(fld_garmin_postal_code) { - unicsv_print_str(GMSD_GET(postal_code, NULL)); + unicsv_print_str(garmin_fs_t::get_postal_code(gmsd, nullptr)); } if FIELD_USED(fld_garmin_state) { - unicsv_print_str(GMSD_GET(state, NULL)); + unicsv_print_str(garmin_fs_t::get_state(gmsd, nullptr)); } if FIELD_USED(fld_garmin_country) { - unicsv_print_str(GMSD_GET(country, NULL)); + unicsv_print_str(garmin_fs_t::get_country(gmsd, nullptr)); } if FIELD_USED(fld_garmin_phone_nr) { - unicsv_print_str(GMSD_GET(phone_nr, NULL)); + unicsv_print_str(garmin_fs_t::get_phone_nr(gmsd, nullptr)); } if FIELD_USED(fld_garmin_phone_nr2) { - unicsv_print_str(GMSD_GET(phone_nr2, NULL)); + unicsv_print_str(garmin_fs_t::get_phone_nr2(gmsd, nullptr)); } if FIELD_USED(fld_garmin_fax_nr) { - unicsv_print_str(GMSD_GET(fax_nr, NULL)); + unicsv_print_str(garmin_fs_t::get_fax_nr(gmsd, nullptr)); } if FIELD_USED(fld_garmin_email) { - unicsv_print_str(GMSD_GET(email, NULL)); + unicsv_print_str(garmin_fs_t::get_email(gmsd, nullptr)); } if (wpt->EmptyGCData()) { diff --git a/waypt.cc b/waypt.cc index 4362bc3d6..2f8bfb5f2 100644 --- a/waypt.cc +++ b/waypt.cc @@ -280,7 +280,7 @@ waypt_distance_ex(const Waypoint* A, const Waypoint* B) return 0; } - if ((gmsd = GMSD_FIND(A)) && (gmsd->ilinks != nullptr)) { + if ((gmsd = garmin_fs_t::find(A)) && (gmsd->ilinks != nullptr)) { garmin_ilink_t* link = gmsd->ilinks; res = gcgeodist(A->latitude, A->longitude, link->lat, link->lon); diff --git a/xcsv.cc b/xcsv.cc index bf8bf5856..035771358 100644 --- a/xcsv.cc +++ b/xcsv.cc @@ -572,7 +572,7 @@ time_to_yyyymmdd(const QDateTime& t) static garmin_fs_t* gmsd_init(Waypoint* wpt) { - garmin_fs_t* gmsd = GMSD_FIND(wpt); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); if (gmsd == nullptr) { gmsd = garmin_fs_alloc(-1); fs_chain_add(&wpt->fs, (format_specific_data*) gmsd); @@ -585,7 +585,7 @@ gmsd_init(Waypoint* wpt) /* usage: xcsv_parse_val("-123.34", *waypt, *field_map) */ /*****************************************************************************/ static void -xcsv_parse_val(const char* s, Waypoint* wpt, const field_map& fmp, +xcsv_parse_val(const QString& value, Waypoint* wpt, const field_map& fmp, xcsv_parse_data* parse_data, const int line_no) { const char* enclosure = ""; @@ -598,6 +598,11 @@ xcsv_parse_val(const char* s, Waypoint* wpt, const field_map& fmp, if (0 == strcmp(fmp.printfc.constData(), "\"%s\"")) { enclosure = "\""; } + + // TODO: eliminate this char string usage. + QByteArray value_utf8 = value.toUtf8(); + const char* s = value_utf8.constData(); + switch (fmp.hashed_key) { case XT_IGNORE: /* IGNORE -- Categorically ignore this... */ @@ -624,16 +629,16 @@ xcsv_parse_val(const char* s, Waypoint* wpt, const field_map& fmp, if (!parse_data->link_) { parse_data->link_ = new UrlLink; } - parse_data->link_->url_ = QString(s).trimmed(); + parse_data->link_->url_ = value.trimmed(); break; case XT_URL_LINK_TEXT: if (!parse_data->link_) { parse_data->link_ = new UrlLink; } - parse_data->link_->url_link_text_ = QString(s).trimmed(); + parse_data->link_->url_link_text_ = value.trimmed(); break; case XT_ICON_DESCR: - wpt->icon_descr = QString(s).trimmed(); + wpt->icon_descr = value.trimmed(); break; /* LATITUDE CONVERSIONS**************************************************/ @@ -801,7 +806,7 @@ xcsv_parse_val(const char* s, Waypoint* wpt, const field_map& fmp, case XT_TIMET_TIME_MS: { /* Time as time_t in milliseconds */ bool ok; - wpt->SetCreationTime(QDateTime::fromMSecsSinceEpoch(QString(s).toLongLong(&ok))); + wpt->SetCreationTime(QDateTime::fromMSecsSinceEpoch(value.toLongLong(&ok))); if (!ok) { warning("parse of string '%s' on line number %d as TIMET_TIME_MS failed.\n", s, line_no); } @@ -858,10 +863,10 @@ xcsv_parse_val(const char* s, Waypoint* wpt, const field_map& fmp, wpt->AllocGCData()->container = gs_mkcont(s); break; case XT_GEOCACHE_HINT: - wpt->AllocGCData()->hint = QString(s).trimmed(); + wpt->AllocGCData()->hint = value.trimmed(); break; case XT_GEOCACHE_PLACER: - wpt->AllocGCData()->placer = QString(s).trimmed(); + wpt->AllocGCData()->placer = value.trimmed(); break; case XT_GEOCACHE_ISAVAILABLE: gc_data = wpt->AllocGCData(); @@ -950,42 +955,42 @@ xcsv_parse_val(const char* s, Waypoint* wpt, const field_map& fmp, /* GMSD ****************************************************************/ case XT_COUNTRY: { garmin_fs_t* gmsd = gmsd_init(wpt); - GMSD_SET(country, csv_stringtrim(s, enclosure, 0)); + garmin_fs_t::set_country(gmsd, csv_stringtrim(value, enclosure, 0)); } break; case XT_STATE: { garmin_fs_t* gmsd = gmsd_init(wpt); - GMSD_SET(state, csv_stringtrim(s, enclosure, 0)); + garmin_fs_t::set_state(gmsd, csv_stringtrim(value, enclosure, 0)); } break; case XT_CITY: { garmin_fs_t* gmsd = gmsd_init(wpt); - GMSD_SET(city, csv_stringtrim(s, enclosure, 0)); + garmin_fs_t::set_city(gmsd, csv_stringtrim(value, enclosure, 0)); } break; case XT_STREET_ADDR: { garmin_fs_t* gmsd = gmsd_init(wpt); - GMSD_SET(addr, csv_stringtrim(s, enclosure, 0)); + garmin_fs_t::set_addr(gmsd, csv_stringtrim(value, enclosure, 0)); } break; case XT_POSTAL_CODE: { garmin_fs_t* gmsd = gmsd_init(wpt); - GMSD_SET(postal_code, csv_stringtrim(s, enclosure, 0)); + garmin_fs_t::set_postal_code(gmsd, csv_stringtrim(value, enclosure, 0)); } break; case XT_PHONE_NR: { garmin_fs_t* gmsd = gmsd_init(wpt); - GMSD_SET(phone_nr, csv_stringtrim(s, enclosure, 0)); + garmin_fs_t::set_phone_nr(gmsd, csv_stringtrim(value, enclosure, 0)); } break; case XT_FACILITY: { garmin_fs_t* gmsd = gmsd_init(wpt); - GMSD_SET(facility, csv_stringtrim(s, enclosure, 0)); + garmin_fs_t::set_facility(gmsd, csv_stringtrim(value, enclosure, 0)); } break; case XT_EMAIL: { garmin_fs_t* gmsd = gmsd_init(wpt); - GMSD_SET(email, csv_stringtrim(s, enclosure, 0)); + garmin_fs_t::set_email(gmsd, csv_stringtrim(value, enclosure, 0)); } break; case -1: @@ -1060,7 +1065,7 @@ xcsv_data_read() /* now rip the line apart */ for (const auto& value : values) { const field_map& fmp = xcsv_file.ifields.at(ifield_idx++); - xcsv_parse_val(CSTR(value), wpt_tmp, fmp, &parse_data, linecount); + xcsv_parse_val(value, wpt_tmp, fmp, &parse_data, linecount); if (ifield_idx >= xcsv_file.ifields.size()) { /* no more fields, stop parsing! */ @@ -1678,42 +1683,42 @@ xcsv_waypt_pr(const Waypoint* wpt) break; /* GMSD ************************************************************/ case XT_COUNTRY: { - garmin_fs_t* gmsd = GMSD_FIND(wpt); - buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(country, "")); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); + buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_country(gmsd, ""))); } break; case XT_STATE: { - garmin_fs_t* gmsd = GMSD_FIND(wpt); - buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(state, "")); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); + buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_state(gmsd, ""))); } break; case XT_CITY: { - garmin_fs_t* gmsd = GMSD_FIND(wpt); - buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(city, "")); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); + buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_city(gmsd, ""))); } break; case XT_POSTAL_CODE: { - garmin_fs_t* gmsd = GMSD_FIND(wpt); - buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(postal_code, "")); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); + buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_postal_code(gmsd, ""))); } break; case XT_STREET_ADDR: { - garmin_fs_t* gmsd = GMSD_FIND(wpt); - buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(addr, "")); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); + buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_addr(gmsd, ""))); } break; case XT_PHONE_NR: { - garmin_fs_t* gmsd = GMSD_FIND(wpt); - buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(phone_nr, "")); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); + buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_phone_nr(gmsd, ""))); } break; case XT_FACILITY: { - garmin_fs_t* gmsd = GMSD_FIND(wpt); - buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(facility, "")); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); + buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_facility(gmsd, ""))); } case XT_EMAIL: { - garmin_fs_t* gmsd = GMSD_FIND(wpt); - buff = QString::asprintf(fmp.printfc.constData(), GMSD_GET(email, "")); + garmin_fs_t* gmsd = garmin_fs_t::find(wpt); + buff = QString::asprintf(fmp.printfc.constData(), CSTR(garmin_fs_t::get_email(gmsd, ""))); } break; /* specials */ diff --git a/xmltag.cc b/xmltag.cc index e3b613453..6ecbd251e 100644 --- a/xmltag.cc +++ b/xmltag.cc @@ -91,6 +91,5 @@ fs_xml* fs_xml_alloc(long type) result->fs.type = type; result->fs.copy = fs_xml_copy; result->fs.destroy = fs_xml_destroy; - result->fs.convert = nullptr; return result; } -- 2.30.2